/**
 * @User: vitobo
 * @Date: 2024-05-21
 * @Description: 继承: 就是对共性的抽取,从而达到对代码的复用
 *      当子类继承父类之后,就会把属性和方法全部继承
 *      子类: 派生类
 *      父类: 基类/超类
 *
 *      一般情况, 继承不要超过三层
 *
 *
 *
 *      2. 重写
 *          1.方法名称相同
 *          2.返回值相同
 *          3.参数列表相同(数据类型,个数,顺序)
 *
 *      子类的访问权限 要 大于等于父类的访问权限
 *      private修饰的方法 是不可以重写的
 *      final修饰的方法, 叫做密封方法, 不能被重写
 *      如果方法被static修饰,也不能被重写
 *      使用@Override 注解 来显式指定重写的方法
 *
 *
 *      问题: 重写 和 重载的区别是什么?
 *      重载:
 *          1.方法名称相同
 *          2.参数列表不同[数据类型,顺序,个数]
 *          3.返回值不做要求
 *
 *      重写:(一定是发生在继承关系上)
 *          1.方法名称相同
 *          2.参数列表不同[数据类型,顺序,个数]
 *          3.返回值相同(返回值构成父子类关系也可以)
 *
 *
 *      向上转型: 把子类对象给父类 Animal animal = dog;
 *         直接赋值/ 方法传参/ 方法返回
 *         动态绑定: 也称为后期绑定, 在编译的时候不能确定方法的行为,程序运行的时候,才能确定具体调用
 *         静态绑定: 前期绑定, 根据用户所传递实参类型就确定了具体调用哪个方法
 *
 *         2.方法的传参过程中,也可以发生向上转型
 *
 *      向下转型:
 *
 *
 *
 *      3. 多态: 一个引用调用同一个方法, 因为这个引用 引用的对象不一样, 导致调用这个方法,所表现的行为不一样, 这种思想就叫做多态
 *          发生多态的条件:
 *              1. 继承情况下
 *              2. 发生向上转型
 *                  1.直接赋值
 *                  2.作为方法的参数
 *                  3.作为方法的返回值
 *              3. 重写
 *
 *
 *
 */


class Animal{

    // 私有的成员可以被继承, 但不能被访问
    public String name;
    public int age;

    public void eat(){
        System.out.println(name + "正在吃饭! ");
    }
}

//  子类 继承 父类
class Dog extends Animal{
    public void barks(){
        System.out.println(name + "汪汪叫! " + "年龄 " + age);
    }
}


class Cat extends Animal{
    public void catchMouse(){
        System.out.println(name + "抓老鼠");
    }
}

public class Test {

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "旺财";
        dog.age = 10;
        dog.barks();
    }
}
